TensorFlow

发表于 | 分类于 ， | | 本文总阅读数 次
| 字数统计: 4k | 阅读时长 ≈ 18
TensorFlow

TensorFlow

背景介绍

  TensorFlow:是谷歌公司于2015年11月9日推出的一个划时代的神经网络，深度学习开发平台。TensorFlow是一个庞大的系统，结构复杂，功能强大，利用**数据流图(Data Flow Graphs)进行数值计算的开源软件库，数据流图中的结点(Node)代表数学运算操作，边(Edge)**代表节点之间流通的数据，即张量(Tensor)。

tensorflow

TensorFlow特点

  TensorFlow具有高度的灵活性：只要能够将计算表示为一个数据流，就可以使用TensorFlow进行运算。
  TensorFlow具有强的可移植性：TensorFlow支持CPU和GPU运算，并且可以运行在个人电脑，服务器，移动设备等。
  TensorFlow运算简单：内部实现了自动求导方式，像搭积木一样，只要建好运算图，不需要关心求导的复杂程度。
  TensorFlow具有功能强大的可视化组建TensorBoard，可以在训练时监控训练过程。

TensorFlow应用

TensorFlow创建tensor

constant方法

1
2
3
4
import tensorflow as tf

# tf.constant(value, dtype=None, shape=None) 创建一个形状为shape，类型为dtype，值为value的张量
a = tf.constant([[1, 2, 3], [4, 5, 6]])

1

CPU，GPU方法

1
2
3
4
5
6
7
8
9
10
11
12
import tensorflow as tf

a = tf.constant([[1, 2, 3], [4, 5, 6]])

# obj.device() 查看tensor的环境是CPU还是GPU
a.device

# obj.gpu() 返回一个新tensor位于GPU 
b = a.gpu()

# obj.cpu() 返回一个新tensor位于CPU
c = b.cpu()

3

numpy，shape，ndim，dtype方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import tensorflow as tf

a = tf.constant([[1, 2, 3], [4, 5, 6]])

# obj.numpy() 返回一个新的ndarray，即将tensor变成numpy数组
b = a.numpy

# obj.shape 查看tensor的维度信息
a.shape

# obj.ndim 查看tensor的维度数
a.ndim

# obj.dtype 查看tensor的类型
a.dtype

3

convert_to_tensor，cast方法

1
2
3
4
5
6
7
8
9
10
import tensorflow as tf
import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6]])

# tf.convert_to_tensor(value, dtype=None) 将value转换为tensor形式，常用来将numpy格式转换为tensor格式
b = tf.convert_to_tensor(a)

# tf.cast(value, dtype) 返回一个值为value，类型为dtype的tensor，常用来修改tensor的类型
c = tf.cast(b, dtype=tf.float32)

4

zeros，ones，fill，random方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import tensorflow as tf

# tf.zeros(shape) 产生形状为shape的值全为0的tensor
a = tf.zeros((3, 3))

# tf.ones(shape) 产生形状为shape的值全为1的tensor
b = tf.ones((3, 3))

# tf.fill(shape, value) 产生形状为shape的值全为value的tensor
c = tf.fill((3, 3), -1) 

# tf.random.normal(shape, mean=0, stddev=1) 产生形状为shape的高斯分布，均值默认为0，标准差默认为1
d = tf.random.normal((3, 3)) 

# tf.random.uniform(shape, mean=0, stddev=1) 产生形状为shape的均匀分布，默认为(0-1)均匀分布
e = tf.random.uniform((3, 3)) 

# tf.random.shuffle(value, seed) 将value按照种子seed打散
f = tf.random.shuffle(d)

5

zeros_like，ones_like，one_hot，range方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import tensorflow as tf

a = tf.random.normal((3, 3))

# tf.zeros_like(input, dtype) 产生一个大小和input相同值为全0的tensor
b = tf.zeros_like(a)

# tf.ones_like(input, dtype) 产生一个大小和input相同值为全1的tensor
c = tf.ones_like(a)

# tf.range(start, end, interval, dtype) 产生从start到end，步长为interval的连续张量，用法同numpy中的arange
d = tf.range(10)

# tf.one_hot(indices, depth) 将indices转换为独热编码，深度为depth
e = tf.one_hot(d, depth=10)

6

TensorFlow切片与索引

[]索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import tensorflow as tf
import numpy as np

a = np.arange(27).reshape((3, 3, 3))
b = tf.convert_to_tensor(a)

# obj[index0][index1]...等价于obj[index0, index1, ...] 索引
b[1][1][1]
b[1, 1, 1]

# obj[start, end, step] 切片索引
b[0:2, 0:2, 0:2]

# obj[...] ...可以代替连续的:
b[..., 0]
b[0, ...]
b[0, ..., 0]

7

gather，gather_nd，boolean_mask方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import tensorflow as tf
import numpy as np

a = np.arange(27).reshape((3, 3, 3))
b = tf.convert_to_tensor(a)

# tf.gather(obj, axis, indices) 在维度axis上索引indices，并且连接成一个新的tensor
c = tf.gather(b, axis=0, indices=[1, 0]) # 在第一个维度上选择前两个，并且将顺序调换
d = tf.gather(b, axis=1, indices=[1, 0]) # 在第二个维度上选择前两个，并且将顺序调换

# tf.gather_nd(obj, indices) 在多维度上索引indices，并且连接成一个新的tensor
e = tf.gather_nd(b, indices=[[0, 0], [1, 1]]) # 索引第1个维度的第一个和第2个维度的第二个数据
f = tf.gather_nd(b, indices=[[0, 0, 0], [0, 0, 1], [0, 0, 2]]) # 索引第1个维度的第1行的第1列，第1个维度的第1行的第2列，第1个维度的第1行的第3列

# tf.boolean_mask(obj, mask, axis) 在axis轴上掩模索引
g = tf.boolean_mask(b, [[True,True,False],[True,False,False],[False,False,False]], axis=0) # 在第一维度上选择前两行，在第二维度上选择第一行，一共三行

8

TensorFlow维度变化

reshape，transpose，expand_dims，squeeze方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import tensorflow as tf
import numpy as np

a = np.arange(4).reshape((2, 1, 2))
b = tf.constant(a)

# tf.reshape(tensor, shape) 返回形状为shape的tensor
c = tf.reshape(a, (2, 2))

# tf.transpose(tensor, perm=None) 将轴进行调换，默认翻转轴
d = tf.transpose(b, (1, 2, 0))

# tf.expand_dims(tensor, axis) 在axis上增加一个维度
e = tf.expand_dims(b, axis=3)

# tf.squeeze(tensor, axis=None) 将axis上为1的维度删去，默认删除所有为1的维度
f = tf.squeeze(e)

9

broadcast_to，tile方法

1
2
3
4
5
6
7
8
9
10
import tensorflow as tf

a = tf.range(3)
b = tf.reshape(a, (1, 3))

# tf.broadcast_to(input, shape) 返回一个广播后的tensor
c = tf.broadcast_to(a, (3, 3))

# tf.tile(input, multiples) 返回一个经过复制的tensor
d = tf.tile(b, [2, 2])

10

TensorFlow合并与分割

concat，stack，unstack，split方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import tensorflow as tf
import numpy as np

a = np.arange(6).reshape((2, 3))
b = np.arange(3, 9).reshape((2, 3))
c = tf.constant(a)
d = tf.constant(b)

# tf.concat(values, axis) 将多个values按照axis轴进行合并
e = tf.concat([c, d], axis=1)

# tf.stack(values, axis) 增加一个新维度，并合并到该维度
f = tf.stack([c, d], axis=1)

# tf.unstack(value, axis) 对value按照axis轴进行拆分
g = tf.unstack(f, axis=1)

# tf.split(value, num_or_size_splits, axis) 对value按照axis轴进行拆分，如果希望均匀拆分则num_or_size_splits为常数，否则输入一个列表，代表每一部分的数量
h = tf.split(e, 3, axis=1)

11

tensorflow数据统计

reduce_min，reduce_max，reduce_mean方法

1
2
3
4
5
6
7
8
9
10
11
12
import tensorflow as tf

a = tf.reshape(tf.random.shuffle(tf.range(1, 13)), (3, 4))

# tf.reduce_min(input_tensor, axis=None) 求input_tensor在axis上的最小值，默认为全局最小值
b = tf.reduce_min(a)

# tf.reduce_max(input_tensor, axis=None) 求input_tensor在axis上的最大值，默认为全局最大值
c = tf.reduce_max(a, axis=0)

# tf.reduce_mean(input_tensor, axis=None) 求input_tensor在axis上的平均值，默认为全局平均值
d = tf.reduce_mean(a, axis=1)

12

argmax，argmin方法

1
2
3
4
5
6
7
8
9
import tensorflow as tf

a = tf.reshape(tf.random.shuffle(tf.range(1, 13)), (3, 4))

# tf.argmax(input, axis=0) 求input在axis轴的最大值索引，默认在第一个轴
b = tf.argmax(a, axis=0)

# tf.argmin(input, axis=0) 求input在axis轴的最小值索引，默认在第一个轴
c = tf.argmin(a, axis=1)

13

equal，unique方法

1
2
3
4
5
6
7
8
9
10
11
import tensorflow as tf

a = tf.constant([[1, 1], [0, 0]])
b = tf.constant([[1, 0], [1, 0]])
c = tf.constant([1,2,3,2,1])

# tf.equal(x, y) 比较x和y是否相等，在如果相等则对应位置为True，否则为False
d = tf.equal(a, b)

# tf.unique(x) 找出x中有多少不同的元素，并返回其索引
e = tf.unique(c)

14

norm，top_k方法

1
2
3
4
5
6
7
8
9
import tensorflow as tf

a = tf.reshape(tf.random.shuffle(tf.range(1, 13, dtype=tf.float32)), (3, 4))

# tf.norm(tensor, str, axis=-1) 求tensor的p范数，默认为全局p范数
b = tf.norm(a, 2, axis=0)

# tf.math.top_k(input, k, bool=True) 在最后一个维度求input中前k个最大值或最小值及其索引，bool=True为最大值，bool=False为最小值。
c = tf.math.top_k(a, 2, True)

15

tensorflow排序

sort，argsort方法

1
2
3
4
5
6
7
8
9
import tensorflow as tf

a = tf.reshape(tf.random.shuffle(tf.range(1, 13)), (3, 4))

# tf.sort(values, direction='ASCENDING', axis=-1) 按axis轴对values进行排序，返回排序后的结果，direction='ASCENDING'代表递增排序，'DESCENDING'代表递减排序
b = tf.sort(a, axis=0)

# tf.argsort(values, direction='ASCENDING', axis=-1) 按axis轴对values进行排序，返回排序后的索引，direction='ASCENDING'代表递增排序，'DESCENDING'代表递减排序
c = tf.argsort(a, axis=1)

16

tensorflow张量限幅

maximun，minimum方法

1
2
3
4
5
6
7
8
9
10
import tensorflow as tf

a = tf.reshape(tf.random.shuffle(tf.range(1, 13)), (3, 4))
b = tf.reshape(tf.random.shuffle(tf.range(1, 13)), (3, 4))

# tf.maximun(x, y) 取x，y中的大数并返回
c = tf.maximum(a, b)

# tf.minimun(x, y) 取x，y中的小数并返回
d = tf.minimum(a, b)

17

clip_by_value方法

1
2
3
4
5
6
import tensorflow as tf

a = tf.reshape(tf.random.shuffle(tf.range(1, 13)), (3, 4))

# tf.clip_by_value(t, clip_value_min, clip_value_max) 将t中小于clip_value_min的值赋值为clip_value_min，大于clip_value_max的值赋值为clip_value_max
b = tf.clip_by_value(a, 3, 7)

18

tensorflow数学运算

常规运算方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import tensorflow as tf

a = tf.reshape(tf.random.shuffle(tf.range(1, 5, dtype=tf.float32)), (2, 2))
b = tf.reshape(tf.random.shuffle(tf.range(1, 5, dtype=tf.float32)), (2, 2))

# tensor1 op tensor2 将tensor1与tensor2进行常规的数学运算，如果维度大小不同，则进行广播，如果不能广播则报错
c = a + b
d = a ** b

# tf.sqrt(x) 将x进行开方运算
e = tf.sqrt(a)

# tf.exp(x) 求e的x次幂
f = tf.exp(a)

# tf.math.log(x) 求x以e为底的对数
g = tf.math.log(a)

19

matmul方法

1
2
3
4
5
6
7
8
import tensorflow as tf

a = tf.reshape(tf.random.shuffle(tf.range(1, 5, dtype=tf.float32)), (2, 2))
b = tf.reshape(tf.random.shuffle(tf.range(1, 5, dtype=tf.float32)), (2, 2))

# tf.matmul(a, b) a和b的矩阵乘法，等价于a @ b
c = tf.matmul(a, b)
d = a @ b

20

where方法

1
2
3
4
5
6
7
8
9
10
11
import tensorflow as tf

a = tf.constant([[False, True], [True, False]])
b = tf.constant([[1, 2], [3, 4]])
c = tf.constant([[-1, -2], [-3, -4]])

# tf.where(obj) 返回obj中True的位置的索引
d = tf.where(a)

# tf.where(tensor1, tensor2, tensor3) 如果tensor1对应位置为True则从tensor2中取得相应元素，否则从tensor3中取得相应元素
e = tf.where(a, b, c)

21

tensorflow深度学习

datasets(数据集)模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import tensorflow as tf
from tensorflow.keras import datasets

# datasets.XXX.load_data() # 下载XXX数据集，常用的有mnist，cifar10，cifar100等等，此时数据为numpy格式，并不是tensor
(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data() # 下载mnist手写数字数据集

x_train.shape
y_train.shape

x_test.shape
y_test.shape

y_train[:6]
y_train_onehot = tf.one_hot(y_train[:6], depth=10)
y_train_onehot

22

data(数据操作)模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import tensorflow as tf

# tf.data.Dataset.from_tensor_slices(tensor) 将tensor数据转换成一个可迭代的对象
db = tf.data.Dataset.from_tensor_slices(x_train)

# next(iter(db)) 返回下一个迭代器的内容

# db.shuffle(n) 将0-n的迭代器内容打散，使其训练更加合理

# db.map(function) 将迭代器中的数据全部经过function处理，常用于图片的预处理等功能

#db.batch(n) 将迭代器中的内容分成很多个batch，每一个batch中有n个数据

# db.repeat(n) 将db对象迭代n次，默认为无限迭代

nn(神经网络)模块

1
2
3
4
5
6
7
8
9
import tensorflow as tf

# tf.nn.relu(features) ReLu激活函数

# tf.nn.sigmoid(features) Sigmoid激活函数

# tf.nn.tanh(features) tanh激活函数

# tf.nn.softmax(logits) softmax层

optimizers(优化器)模块

1
2
3
4
5
6
7
from tensorflow.keras import optimizers

# optimizers.SGD(lr=0.01, momentum=0.0, decay=0.0, nesterov=False) 随机梯度下降优化器，学习率lr默认为0.01，动量momentum默认为0，学习率衰减decay默认为0，默认不使用nesterov动量

# optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=None, decay=0.0) RMSprop优化器，学习率lr默认为0.001，参数rho默认为0.9，模糊因子epsilon默认为None，学习率衰减decay默认为0.0

# optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0) Adam优化器，学习率lr默认为0.001，参数beta_1默认为0.9, 参数beta_2默认为0.999，模糊因子epsilon默认为None，学习率衰减decay默认为0

layers(网络层)模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import tensorflow as tf
from tensorflow.keras import layers

# layers.Dense(out_dim) 建立一个全连接层，结点数为out_dim个

# layers.Layer 自定义网络层的基类
class MyDense(layers.Layer):
    def __init__(self, input_dim, output_dim):
        super(MyDense, self).__init__()
        
        self.kernel = self.add_variable('w', [input_dim, output_dim])
        self.bias = self.add_variable('b', [output_dim])

    def call(self, inputs, training=None):
        out = inputs @ self.kernel + self.bias
        return out

# layers.Dropout(rate) 建立一个Dropout层，失活的比率为rate，保持连接的比率为1-rate，和PyTorch相同

# layers.Flatten() 建立一个Flatten层，将数据展平成一维

# layers.Conv2D(filters, kernel_size, strides=(1, 1), padding='valid') 建立一个卷积层，卷积核的个数为filters，核的大小为kernel_size，strides为模板移动的步长，padding为是否在周围补0，valid为不补0，same为补0保证大小不变

# layers.MaxPool2D(pool_size=(2, 2), strides=None, padding='valid') 建立一个最大值池化层(平均值池化为AveragePooling2D)，池化层模板为pool_size，strides为模板移动的步长，padding为是否在周围补0，valid为不补0，same为补0保证大小不变

# layers.SimpleRNNCell(units, activation='tanh', dropout=0.0, return_sequences=False, unroll=False) 建立一个循环神经网络层，单元数为units，dropout丢弃百分百为0.0，return_sequences=False返回序列最后一个输出，return_sequences=True返回全部序列，unroll=True，则网络将展开，否则将使用符号循环。

# layers.LSTM(units, activation='tanh', dropout=0.0, return_sequences=False, unroll=False) 建立一个长短期记忆网络，单元数为units，dropout丢弃百分百为0.0，return_sequences=False返回序列最后一个输出，return_sequences=True返回全部序列，unroll=True，则网络将展开，否则将使用符号循环。

losses(误差计算)模块

1
2
3
4
5
6
7
import tensorflow as tf

# tf.losses.MSE(y, logits) 计算真实值y与预测值logits的均方差

# tf.losses.categorical_crossentropy(y, logits) 计算真实值y与预测值logits的交叉熵

# tf.losses.binary_crossentropy(label, prob) 根据标签和概率计算二分类问题的交叉熵

Gradient(梯度下降)模块

1
2
3
4
5
6
7
import tensorflow as tf

# tf.Variable(tensor) 将tensor赋有可求导属性

# 将前向运算过程放在tf.GradientTape()中，即可实现自动求导，前提是变量具有可导属性
with tf.GradientTape() as tape：
    XXX

TensorBoard模块

1
2
3
4
5
6
7
# 首先要安装TensorBoard，pip install tensorboard
# 新建一个文件夹，命名为logs，在该文件路径下并输入tensorboard --logdir logs  会显示TensorBoard 1.14.0 at http://DESKTOP-1NSILG1:6006/ (Press CTRL+C to quit)
# 建立日志文件tf.summary.create_file_writer(filename)
# 给日志写数据
with summary_writer.as_default():
    tf.summary.scalar(label, data, step) # 给label添加数据data，以step作为x轴
    tf.summary.image(label, img, step) # 给label添加图片img

24

visdom模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 首先要安装visdom，pip install visdom
# 在该文件路径下并输入python -m visdom.server，会出现下面的提示
Checking for scripts.
It's Alive!
INFO:root:Application Started
You can navigate to http://localhost:8097
# 在python文件中写入
from visdom import Visdom

vis = Visdom()

# vis.line(Y, X, win, updata) 在win窗口下创建横坐标为X，纵坐标为Y的折线，updata为折线的更新方式

# vis.images(tensor, win) 在win窗口下显示图片tensor

# vis.text(text, win) 在win窗口下显示text文本文字

24

metrics(衡量指标)模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from tensorflow.keras import metrics

# metrics.Accuracy() 返回准确度衡量指标对象
acc_metrics = metrics.Accuracy()

# metrics.Mean() 返回平均值衡量指标对象
mean_metrics = metrics.Mean()

# obj.updata_state() 向metrics对象中添加数据
acc_metrics.updata_state(loss)
mean_metrics.updata_state(y, pred)

# obj.result() 将metrics中的数据取出
acc_metrics.result()
mean_metrics.result()

# obj.reset_states() 清除metrics中的数据
acc_metrics.reset_states()
mean_metrics.reset_states()

Model(模型)模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import tensorflow as tf
from tensorflow.keras import Sequential, layers
from tensorflow import keras

# model = Sequential([layer1, layer2, ...]) 创建一个网络结构，第一层为layer1，第二层为layer2，……
model = Sequential([layers.Dense(512), layers.Dense(128), layers.Dense(10)])

# keras.Model 自定义网络结构的基类
class MyModel(keras.Model):
    def __init__(self):
        super(MyModel, self).__init__()
        
        self.fc1 = MyDense(28 * 28, 256)
        self.fc2 = MyDense(256, 64)
        self.fc3 = MyDense(64, 10)

    def call(self, inputs, training=None):
        x = self.fc1(inputs)
        x = tf.nn.relu(x)
        x = self.fc2(x)
        x = tf.nn.relu(x)
        x = self.fc3(x)
        return x


# model.build(input_shape) 定义网络输入的形状
model.build(input_shape=(None, 784))

# model.summary() 查看网络结构
model.summary()

# model.trainable_variables 查看网络所有可训练参数
model.trainable_variables

# model.compile(optimizer, loss, metrics) 配置训练模型，设置优化器为optimizer，损失函数为loss，衡量指标为metrics

# model.fit(db, epoch, validation_data, validation_freq) 训练模型，训练集为db，训练epoch次，validation_freq次对validation_data进行一次测试，防止过拟合

# model.evaluate(db_test) 对测试集进行测试

# model.predict(x) 对未知的数据进行预测

23

save(保存)模块

1
2
3
4
5
6
7
8
9
import tensorflow as tf

# model.save_weights(filename) 将网络的训练参数保存在filename中，仅仅保存权值
# model.load_weights(filename) 读取filename中的训练参数，前提是要创建一个相同结构的网络

# model.save(filename) 保存网络的所有结构和参数
# tf.keras.models.load_model(filename) 读取模型，不需要创建网络，会生成一个相同的网络

# tf.saved_model.save(model, filename) 保存网络的所有结构和参数，便于给其他语言提供调用

TensorFlow小结

  由于TensorFlow背靠谷歌，具有最全的文档和资源，而且很多模型都有TensorFlow的源码实现，所以拥有较大的用户基数，这样使用户出现问题时能较容易地找到解决方案，这使TensorFlow目前作为最流行的深度学习框架。

-------------本文结束感谢您的阅读-------------
0%